import aiomysql

async def add(pool: aiomysql.Pool, table_name: str, data: dict) -> int:
    """
    向指定表插入一条数据
    
    Args:
        pool: aiomysql连接池对象
        table_name: 要插入数据的表名
        data: 要插入的数据字典，键为列名，值为要插入的值
        
    Returns:
        int: 插入行的主键ID
        
    Raises:
        aiomysql.Error: 如果插入操作失败会抛出异常
    """
    async with pool.acquire() as conn:
        async with conn.cursor() as cur:
            # 构建列名和值列表
            columns = ', '.join(data.keys())
            placeholders = ', '.join(['%s'] * len(data))
            
            # 使用execute方法执行插入操作
            await cur.execute(f"INSERT INTO {table_name} ({columns}) VALUES ({placeholders})", tuple(data.values()))
            
            # 获取插入行的ID
            await conn.commit()
            return cur.lastrowid


async def delete(pool: aiomysql.Pool, table_name: str, id: int) -> int:
    """
    根据ID删除指定表的数据
    
    Args:
        pool: aiomysql连接池对象
        table_name: 要删除数据的表名
        id: 要删除的记录ID
        
    Returns:
        int: 受影响的行数
        
    Raises:
        aiomysql.Error: 如果删除操作失败会抛出异常
    """
    async with pool.acquire() as conn:
        async with conn.cursor() as cur:
            # 使用execute方法执行删除操作
            await cur.execute(
                f"DELETE FROM {table_name} WHERE id = %s",
                (id,)
            )
            
            # 提交事务并返回受影响的行数
            await conn.commit()
            return cur.rowcount


async def get(pool: aiomysql.Pool, table_name: str, id: int) -> dict:
    """
    根据ID查询指定表的数据
    
    Args:
        pool: aiomysql连接池对象
        table_name: 要查询的表名
        id: 要查询的记录ID
        
    Returns:
        dict: 查询到的数据记录，如果没有找到则返回None
        
    Raises:
        aiomysql.Error: 如果查询操作失败会抛出异常
    """
    async with pool.acquire() as conn:
        async with conn.cursor() as cur:
            # 使用execute方法执行查询操作
            await cur.execute(
                f"SELECT * FROM {table_name} WHERE id = %s",
                (id,)
            )
            
            # 获取查询结果
            result = await cur.fetchone()
            if result:
                # 将结果转换为字典
                columns = [column[0] for column in cur.description]
                return dict(zip(columns, result))
            return None


async def get_all(pool: aiomysql.Pool, table_name: str) -> list[dict]:
    """
    查询指定表中的所有数据
    
    Args:
        pool: aiomysql连接池对象
        table_name: 要查询的表名
        
    Returns:
        list[dict]: 包含所有数据记录的列表，如果没有数据则返回空列表
        
    Raises:
        aiomysql.Error: 如果查询操作失败会抛出异常
    """
    async with pool.acquire() as conn:
        async with conn.cursor() as cur:
            # 使用execute方法执行查询操作
            await cur.execute(f"SELECT * FROM {table_name}")
            
            # 获取所有查询结果
            results = await cur.fetchall()
            if results:
                # 将结果转换为字典列表
                columns = [column[0] for column in cur.description]
                return [dict(zip(columns, row)) for row in results]
            return []


async def update(pool: aiomysql.Pool, table_name: str, id: int, data: dict) -> int:
    """
    根据ID更新指定表的数据
    
    Args:
        pool: aiomysql连接池对象
        table_name: 要更新的表名
        id: 要更新的记录ID
        data: 要更新的数据字典，键为列名，值为要更新的值
        
    Returns:
        int: 受影响的行数
        
    Raises:
        aiomysql.Error: 如果更新操作失败会抛出异常
    """
    async with pool.acquire() as conn:
        async with conn.cursor() as cur:
            # 构建SET子句
            set_clause = ', '.join([f"{column} = %s" for column in data.keys()])
            
            # 使用execute方法执行更新操作
            await cur.execute(
                f"UPDATE {table_name} SET {set_clause} WHERE id = %s",
                tuple(data.values()) + (id,)
            )
            
            # 提交事务并返回受影响的行数
            await conn.commit()
            return cur.rowcount


async def get_page(pool: aiomysql.Pool, table_name: str, page: int, page_size: int) -> list[dict]:
    """
    分页查询指定表的数据
    
    Args:
        pool: aiomysql连接池对象
        table_name: 要查询的表名
        page: 页码(从1开始)
        page_size: 每页记录数
        
    Returns:
        list[dict]: 包含分页数据记录的列表，如果没有数据则返回空列表
        
    Raises:
        aiomysql.Error: 如果查询操作失败会抛出异常
    """
    async with pool.acquire() as conn:
        async with conn.cursor() as cur:
            # 计算偏移量
            offset = (page - 1) * page_size
            
            # 使用execute方法执行分页查询
            await cur.execute(
                f"SELECT * FROM {table_name} LIMIT %s OFFSET %s",
                (page_size, offset)
            )
            
            # 获取查询结果
            results = await cur.fetchall()
            if results:
                # 将结果转换为字典列表
                columns = [column[0] for column in cur.description]
                return [dict(zip(columns, row)) for row in results]
            return []